home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Magazine / GraphicsCards / StormMesa / src / pixel.c < prev    next >
C/C++ Source or Header  |  1999-02-04  |  23KB  |  808 lines
  1. /* $Id: pixel.c,v 3.7 1998/09/29 01:35:41 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  3.0
  6.  * Copyright (C) 1995-1998  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: pixel.c,v $
  26.  * Revision 3.7  1998/09/29 01:35:41  brianp
  27.  * glPixelStore() now handles GL_PACK/UNPACK_IMAGE_HEIGHT
  28.  *
  29.  * Revision 3.6  1998/07/17 03:23:47  brianp
  30.  * added a bunch of const's
  31.  *
  32.  * Revision 3.5  1998/03/27 04:17:31  brianp
  33.  * fixed G++ warnings
  34.  *
  35.  * Revision 3.4  1998/03/22 16:42:05  brianp
  36.  * added 8-bit CI->RGBA pixel mapping tables
  37.  *
  38.  * Revision 3.3  1998/02/08 20:21:42  brianp
  39.  * added a bunch of rgba, ci and stencil scaling, biasing and mapping functions
  40.  *
  41.  * Revision 3.2  1998/02/01 22:27:57  brianp
  42.  * removed obsolete call to update_drawpixels_state()
  43.  *
  44.  * Revision 3.1  1998/02/01 22:15:39  brianp
  45.  * moved pixel zoom code into zoom.c
  46.  *
  47.  * Revision 3.0  1998/01/31 21:00:28  brianp
  48.  * initial rev
  49.  *
  50.  */
  51.  
  52.  
  53. /*
  54.  * glPixelStore, glPixelTransfer, glPixelMap, glPixelZoom, etc.
  55.  */
  56.  
  57.  
  58. #ifdef PC_HEADER
  59. #include "all.h"
  60. #else
  61. #include <assert.h>
  62. #include <stdio.h>
  63. #include <stdlib.h>
  64. #include "context.h"
  65. #include "macros.h"
  66. #include "pixel.h"
  67. #include "types.h"
  68. #endif
  69.  
  70.  
  71.  
  72. /**********************************************************************/
  73. /*****                    glPixelZoom                             *****/
  74. /**********************************************************************/
  75.  
  76.  
  77.  
  78. void gl_PixelZoom( GLcontext *ctx, GLfloat xfactor, GLfloat yfactor )
  79. {
  80.    if (INSIDE_BEGIN_END(ctx)) {
  81.       gl_error( ctx, GL_INVALID_OPERATION, "glPixelZoom" );
  82.       return;
  83.    }
  84.    ctx->Pixel.ZoomX = xfactor;
  85.    ctx->Pixel.ZoomY = yfactor;
  86. }
  87.  
  88.  
  89.  
  90. /**********************************************************************/
  91. /*****                    glPixelStore                            *****/
  92. /**********************************************************************/
  93.  
  94.  
  95. void gl_PixelStorei( GLcontext *ctx, GLenum pname, GLint param )
  96. {
  97.    /* NOTE: this call can't be compiled into the display list */
  98.  
  99.    if (INSIDE_BEGIN_END(ctx)) {
  100.       gl_error( ctx, GL_INVALID_OPERATION, "glPixelStore" );
  101.       return;
  102.    }
  103.  
  104.    switch (pname) {
  105.       case GL_PACK_SWAP_BYTES:
  106.          ctx->Pack.SwapBytes = param ? GL_TRUE : GL_FALSE;
  107.      break;
  108.       case GL_PACK_LSB_FIRST:
  109.          ctx->Pack.LsbFirst = param ? GL_TRUE : GL_FALSE;
  110.      break;
  111.       case GL_PACK_ROW_LENGTH:
  112.      if (param<0) {
  113.         gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
  114.      }
  115.      else {
  116.         ctx->Pack.RowLength = param;
  117.      }
  118.      break;
  119.       case GL_PACK_IMAGE_HEIGHT:
  120.          if (param<0)
  121.             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
  122.          else
  123.             ctx->Pack.ImageHeight = param;
  124.          break;
  125.       case GL_PACK_SKIP_PIXELS:
  126.      if (param<0) {
  127.         gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
  128.      }
  129.      else {
  130.         ctx->Pack.SkipPixels = param;
  131.      }
  132.      break;
  133.       case GL_PACK_SKIP_ROWS:
  134.      if (param<0) {
  135.         gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
  136.      }
  137.      else {
  138.         ctx->Pack.SkipRows = param;
  139.      }
  140.      break;
  141.       case GL_PACK_ALIGNMENT:
  142.          if (param==1 || param==2 || param==4 || param==8) {
  143.         ctx->Pack.Alignment = param;
  144.      }
  145.      else {
  146.         gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
  147.      }
  148.      break;
  149.       case GL_UNPACK_SWAP_BYTES:
  150.      ctx->Unpack.SwapBytes = param ? GL_TRUE : GL_FALSE;
  151.          break;
  152.       case GL_UNPACK_LSB_FIRST:
  153.      ctx->Unpack.LsbFirst = param ? GL_TRUE : GL_FALSE;
  154.      break;
  155.       case GL_UNPACK_ROW_LENGTH:
  156.      if (param<0) {
  157.         gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
  158.      }
  159.      else {
  160.         ctx->Unpack.RowLength = param;
  161.      }
  162.      break;
  163.       case GL_UNPACK_IMAGE_HEIGHT:
  164.          if (param<0)
  165.             gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
  166.          else
  167.             ctx->Unpack.ImageHeight = param;
  168.          break;
  169.       case GL_UNPACK_SKIP_PIXELS:
  170.      if (param<0) {
  171.         gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
  172.      }
  173.      else {
  174.         ctx->Unpack.SkipPixels = param;
  175.      }
  176.      break;
  177.       case GL_UNPACK_SKIP_ROWS:
  178.      if (param<0) {
  179.         gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
  180.      }
  181.      else {
  182.         ctx->Unpack.SkipRows = param;
  183.      }
  184.      break;
  185.       case GL_UNPACK_ALIGNMENT:
  186.          if (param==1 || param==2 || param==4 || param==8) {
  187.         ctx->Unpack.Alignment = param;
  188.      }
  189.      else {
  190.         gl_error( ctx, GL_INVALID_VALUE, "glPixelStore" );
  191.      }
  192.      break;
  193.       default:
  194.      gl_error( ctx, GL_INVALID_ENUM, "glPixelStore" );
  195.    }
  196. }
  197.  
  198.  
  199.  
  200.  
  201.  
  202. /**********************************************************************/
  203. /*****                         glPixelMap                         *****/
  204. /**********************************************************************/
  205.  
  206.  
  207.  
  208. void gl_PixelMapfv( GLcontext *ctx,
  209.                     GLenum map, GLint mapsize, const GLfloat *values )
  210. {
  211.    GLint i;
  212.  
  213.    if (INSIDE_BEGIN_END(ctx)) {
  214.       gl_error( ctx, GL_INVALID_OPERATION, "glPixelMapfv" );
  215.       return;
  216.    }
  217.  
  218.    if (mapsize<0 || mapsize>MAX_PIXEL_MAP_TABLE) {
  219.       gl_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
  220.       return;
  221.    }
  222.  
  223.    if (map>=GL_PIXEL_MAP_S_TO_S && map<=GL_PIXEL_MAP_I_TO_A) {
  224.       /* test that mapsize is a power of two */
  225.       GLuint p;
  226.       GLboolean ok = GL_FALSE;
  227.       for (p=1; p<=MAX_PIXEL_MAP_TABLE; p=p<<1) {
  228.      if ( (p&mapsize) == p ) {
  229.         ok = GL_TRUE;
  230.         break;
  231.      }
  232.       }
  233.       if (!ok) {
  234.      gl_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
  235.          return;
  236.       }
  237.    }
  238.  
  239.    switch (map) {
  240.       case GL_PIXEL_MAP_S_TO_S:
  241.          ctx->Pixel.MapStoSsize = mapsize;
  242.          for (i=0;i<mapsize;i++) {
  243.         ctx->Pixel.MapStoS[i] = (GLint) values[i];
  244.      }
  245.      break;
  246.       case GL_PIXEL_MAP_I_TO_I:
  247.          ctx->Pixel.MapItoIsize = mapsize;
  248.          for (i=0;i<mapsize;i++) {
  249.         ctx->Pixel.MapItoI[i] = (GLint) values[i];
  250.      }
  251.      break;
  252.       case GL_PIXEL_MAP_I_TO_R:
  253.          ctx->Pixel.MapItoRsize = mapsize;
  254.          for (i=0;i<mapsize;i++) {
  255.             GLfloat val = CLAMP( values[i], 0.0, 1.0 );
  256.         ctx->Pixel.MapItoR[i] = val;
  257.         ctx->Pixel.MapItoR8[i] = (GLint) (val * 255.0F);
  258.      }
  259.      break;
  260.       case GL_PIXEL_MAP_I_TO_G:
  261.          ctx->Pixel.MapItoGsize = mapsize;
  262.          for (i=0;i<mapsize;i++) {
  263.             GLfloat val = CLAMP( values[i], 0.0, 1.0 );
  264.         ctx->Pixel.MapItoG[i] = val;
  265.         ctx->Pixel.MapItoG8[i] = (GLint) (val * 255.0F);
  266.      }
  267.      break;
  268.       case GL_PIXEL_MAP_I_TO_B:
  269.          ctx->Pixel.MapItoBsize = mapsize;
  270.          for (i=0;i<mapsize;i++) {
  271.             GLfloat val = CLAMP( values[i], 0.0, 1.0 );
  272.         ctx->Pixel.MapItoB[i] = val;
  273.         ctx->Pixel.MapItoB8[i] = (GLint) (val * 255.0F);
  274.      }
  275.      break;
  276.       case GL_PIXEL_MAP_I_TO_A:
  277.          ctx->Pixel.MapItoAsize = mapsize;
  278.          for (i=0;i<mapsize;i++) {
  279.             GLfloat val = CLAMP( values[i], 0.0, 1.0 );
  280.         ctx->Pixel.MapItoA[i] = val;
  281.         ctx->Pixel.MapItoA8[i] = (GLint) (val * 255.0F);
  282.      }
  283.      break;
  284.       case GL_PIXEL_MAP_R_TO_R:
  285.          ctx->Pixel.MapRtoRsize = mapsize;
  286.          for (i=0;i<mapsize;i++) {
  287.         ctx->Pixel.MapRtoR[i] = CLAMP( values[i], 0.0, 1.0 );
  288.      }
  289.      break;
  290.       case GL_PIXEL_MAP_G_TO_G:
  291.          ctx->Pixel.MapGtoGsize = mapsize;
  292.          for (i=0;i<mapsize;i++) {
  293.         ctx->Pixel.MapGtoG[i] = CLAMP( values[i], 0.0, 1.0 );
  294.      }
  295.      break;
  296.       case GL_PIXEL_MAP_B_TO_B:
  297.          ctx->Pixel.MapBtoBsize = mapsize;
  298.          for (i=0;i<mapsize;i++) {
  299.         ctx->Pixel.MapBtoB[i] = CLAMP( values[i], 0.0, 1.0 );
  300.      }
  301.      break;
  302.       case GL_PIXEL_MAP_A_TO_A:
  303.          ctx->Pixel.MapAtoAsize = mapsize;
  304.          for (i=0;i<mapsize;i++) {
  305.         ctx->Pixel.MapAtoA[i] = CLAMP( values[i], 0.0, 1.0 );
  306.      }
  307.      break;
  308.       default:
  309.          gl_error( ctx, GL_INVALID_ENUM, "glPixelMapfv(map)" );
  310.    }
  311. }
  312.  
  313.  
  314.  
  315.  
  316.  
  317. void gl_GetPixelMapfv( GLcontext *ctx, GLenum map, GLfloat *values )
  318. {
  319.    GLint i;
  320.  
  321.    if (INSIDE_BEGIN_END(ctx)) {
  322.       gl_error( ctx, GL_INVALID_OPERATION, "glGetPixelMapfv" );
  323.       return;
  324.    }
  325.    switch (map) {
  326.       case GL_PIXEL_MAP_I_TO_I:
  327.          for (i=0;i<ctx->Pixel.MapItoIsize;i++) {
  328.         values[i] = (GLfloat) ctx->Pixel.MapItoI[i];
  329.      }
  330.      break;
  331.       case GL_PIXEL_MAP_S_TO_S:
  332.          for (i=0;i<ctx->Pixel.MapStoSsize;i++) {
  333.         values[i] = (GLfloat) ctx->Pixel.MapStoS[i];
  334.      }
  335.      break;
  336.       case GL_PIXEL_MAP_I_TO_R:
  337.          MEMCPY(values,ctx->Pixel.MapItoR,ctx->Pixel.MapItoRsize*sizeof(GLfloat));
  338.      break;
  339.       case GL_PIXEL_MAP_I_TO_G:
  340.          MEMCPY(values,ctx->Pixel.MapItoG,ctx->Pixel.MapItoGsize*sizeof(GLfloat));
  341.      break;
  342.       case GL_PIXEL_MAP_I_TO_B:
  343.          MEMCPY(values,ctx->Pixel.MapItoB,ctx->Pixel.MapItoBsize*sizeof(GLfloat));
  344.      break;
  345.       case GL_PIXEL_MAP_I_TO_A:
  346.          MEMCPY(values,ctx->Pixel.MapItoA,ctx->Pixel.MapItoAsize*sizeof(GLfloat));
  347.      break;
  348.       case GL_PIXEL_MAP_R_TO_R:
  349.          MEMCPY(values,ctx->Pixel.MapRtoR,ctx->Pixel.MapRtoRsize*sizeof(GLfloat));
  350.      break;
  351.       case GL_PIXEL_MAP_G_TO_G:
  352.          MEMCPY(values,ctx->Pixel.MapGtoG,ctx->Pixel.MapGtoGsize*sizeof(GLfloat));
  353.      break;
  354.       case GL_PIXEL_MAP_B_TO_B:
  355.          MEMCPY(values,ctx->Pixel.MapBtoB,ctx->Pixel.MapBtoBsize*sizeof(GLfloat));
  356.      break;
  357.       case GL_PIXEL_MAP_A_TO_A:
  358.          MEMCPY(values,ctx->Pixel.MapAtoA,ctx->Pixel.MapAtoAsize*sizeof(GLfloat));
  359.      break;
  360.       default:
  361.          gl_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
  362.    }
  363. }
  364.  
  365.  
  366. void gl_GetPixelMapuiv( GLcontext *ctx, GLenum map, GLuint *values )
  367. {
  368.    GLint i;
  369.  
  370.    if (INSIDE_BEGIN_END(ctx)) {
  371.       gl_error( ctx, GL_INVALID_OPERATION, "glGetPixelMapfv" );
  372.       return;
  373.    }
  374.    switch (map) {
  375.       case GL_PIXEL_MAP_I_TO_I:
  376.          MEMCPY(values, ctx->Pixel.MapItoI, ctx->Pixel.MapItoIsize*sizeof(GLint));
  377.      break;
  378.       case GL_PIXEL_MAP_S_TO_S:
  379.          MEMCPY(values, ctx->Pixel.MapStoS, ctx->Pixel.MapStoSsize*sizeof(GLint));
  380.      break;
  381.       case GL_PIXEL_MAP_I_TO_R:
  382.      for (i=0;i<ctx->Pixel.MapItoRsize;i++) {
  383.         values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoR[i] );
  384.      }
  385.      break;
  386.       case GL_PIXEL_MAP_I_TO_G:
  387.      for (i=0;i<ctx->Pixel.MapItoGsize;i++) {
  388.         values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoG[i] );
  389.      }
  390.      break;
  391.       case GL_PIXEL_MAP_I_TO_B:
  392.      for (i=0;i<ctx->Pixel.MapItoBsize;i++) {
  393.         values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoB[i] );
  394.      }
  395.      break;
  396.       case GL_PIXEL_MAP_I_TO_A:
  397.      for (i=0;i<ctx->Pixel.MapItoAsize;i++) {
  398.         values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoA[i] );
  399.      }
  400.      break;
  401.       case GL_PIXEL_MAP_R_TO_R:
  402.      for (i=0;i<ctx->Pixel.MapRtoRsize;i++) {
  403.         values[i] = FLOAT_TO_UINT( ctx->Pixel.MapRtoR[i] );
  404.      }
  405.      break;
  406.       case GL_PIXEL_MAP_G_TO_G:
  407.      for (i=0;i<ctx->Pixel.MapGtoGsize;i++) {
  408.         values[i] = FLOAT_TO_UINT( ctx->Pixel.MapGtoG[i] );
  409.      }
  410.      break;
  411.       case GL_PIXEL_MAP_B_TO_B:
  412.      for (i=0;i<ctx->Pixel.MapBtoBsize;i++) {
  413.         values[i] = FLOAT_TO_UINT( ctx->Pixel.MapBtoB[i] );
  414.      }
  415.      break;
  416.       case GL_PIXEL_MAP_A_TO_A:
  417.      for (i=0;i<ctx->Pixel.MapAtoAsize;i++) {
  418.         values[i] = FLOAT_TO_UINT( ctx->Pixel.MapAtoA[i] );
  419.      }
  420.      break;
  421.       default:
  422.          gl_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
  423.    }
  424. }
  425.  
  426.  
  427. void gl_GetPixelMapusv( GLcontext *ctx, GLenum map, GLushort *values )
  428. {
  429.    GLint i;
  430.  
  431.    if (INSIDE_BEGIN_END(ctx)) {
  432.       gl_error( ctx, GL_INVALID_OPERATION, "glGetPixelMapfv" );
  433.       return;
  434.    }
  435.    switch (map) {
  436.       case GL_PIXEL_MAP_I_TO_I:
  437.      for (i=0;i<ctx->Pixel.MapItoIsize;i++) {
  438.         values[i] = (GLushort) ctx->Pixel.MapItoI[i];
  439.      }
  440.      break;
  441.       case GL_PIXEL_MAP_S_TO_S:
  442.      for (i=0;i<ctx->Pixel.MapStoSsize;i++) {
  443.         values[i] = (GLushort) ctx->Pixel.MapStoS[i];
  444.      }
  445.      break;
  446.       case GL_PIXEL_MAP_I_TO_R:
  447.      for (i=0;i<ctx->Pixel.MapItoRsize;i++) {
  448.         values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoR[i] );
  449.      }
  450.      break;
  451.       case GL_PIXEL_MAP_I_TO_G:
  452.      for (i=0;i<ctx->Pixel.MapItoGsize;i++) {
  453.         values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoG[i] );
  454.      }
  455.      break;
  456.       case GL_PIXEL_MAP_I_TO_B:
  457.      for (i=0;i<ctx->Pixel.MapItoBsize;i++) {
  458.         values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoB[i] );
  459.      }
  460.      break;
  461.       case GL_PIXEL_MAP_I_TO_A:
  462.      for (i=0;i<ctx->Pixel.MapItoAsize;i++) {
  463.         values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoA[i] );
  464.      }
  465.      break;
  466.       case GL_PIXEL_MAP_R_TO_R:
  467.      for (i=0;i<ctx->Pixel.MapRtoRsize;i++) {
  468.         values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapRtoR[i] );
  469.      }
  470.      break;
  471.       case GL_PIXEL_MAP_G_TO_G:
  472.      for (i=0;i<ctx->Pixel.MapGtoGsize;i++) {
  473.         values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapGtoG[i] );
  474.      }
  475.      break;
  476.       case GL_PIXEL_MAP_B_TO_B:
  477.      for (i=0;i<ctx->Pixel.MapBtoBsize;i++) {
  478.         values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapBtoB[i] );
  479.      }
  480.      break;
  481.       case GL_PIXEL_MAP_A_TO_A:
  482.      for (i=0;i<ctx->Pixel.MapAtoAsize;i++) {
  483.         values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapAtoA[i] );
  484.      }
  485.      break;
  486.       default:
  487.          gl_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
  488.    }
  489. }
  490.  
  491.  
  492.  
  493. /**********************************************************************/
  494. /*****                       glPixelTransfer                      *****/
  495. /**********************************************************************/
  496.  
  497.  
  498. /*
  499.  * Implements glPixelTransfer[fi] whether called immediately or from a
  500.  * display list.
  501.  */
  502. void gl_PixelTransferf( GLcontext *ctx, GLenum pname, GLfloat param )
  503. {
  504.    if (INSIDE_BEGIN_END(ctx)) {
  505.       gl_error( ctx, GL_INVALID_OPERATION, "glPixelTransfer" );
  506.       return;
  507.    }
  508.  
  509.    switch (pname) {
  510.       case GL_MAP_COLOR:
  511.          ctx->Pixel.MapColorFlag = param ? GL_TRUE : GL_FALSE;
  512.      break;
  513.       case GL_MAP_STENCIL:
  514.          ctx->Pixel.MapStencilFlag = param ? GL_TRUE : GL_FALSE;
  515.      break;
  516.       case GL_INDEX_SHIFT:
  517.          ctx->Pixel.IndexShift = (GLint) param;
  518.      break;
  519.       case GL_INDEX_OFFSET:
  520.          ctx->Pixel.IndexOffset = (GLint) param;
  521.      break;
  522.       case GL_RED_SCALE:
  523.          ctx->Pixel.RedScale = param;
  524.      break;
  525.       case GL_RED_BIAS:
  526.          ctx->Pixel.RedBias = param;
  527.      break;
  528.       case GL_GREEN_SCALE:
  529.          ctx->Pixel.GreenScale = param;
  530.      break;
  531.       case GL_GREEN_BIAS:
  532.          ctx->Pixel.GreenBias = param;
  533.      break;
  534.       case GL_BLUE_SCALE:
  535.          ctx->Pixel.BlueScale = param;
  536.      break;
  537.       case GL_BLUE_BIAS:
  538.          ctx->Pixel.BlueBias = param;
  539.      break;
  540.       case GL_ALPHA_SCALE:
  541.          ctx->Pixel.AlphaScale = param;
  542.      break;
  543.       case GL_ALPHA_BIAS:
  544.          ctx->Pixel.AlphaBias = param;
  545.      break;
  546.       case GL_DEPTH_SCALE:
  547.          ctx->Pixel.DepthScale = param;
  548.      break;
  549.       case GL_DEPTH_BIAS:
  550.          ctx->Pixel.DepthBias = param;
  551.      break;
  552.       default:
  553.          gl_error( ctx, GL_INVALID_ENUM, "glPixelTransfer(pname)" );
  554.          return;
  555.    }
  556.  
  557.    if (ctx->Pixel.RedScale!=1.0F   || ctx->Pixel.RedBias!=0.0F ||
  558.        ctx->Pixel.GreenScale!=1.0F || ctx->Pixel.GreenBias!=0.0F ||
  559.        ctx->Pixel.BlueScale!=1.0F  || ctx->Pixel.BlueBias!=0.0F ||
  560.        ctx->Pixel.AlphaScale!=1.0F || ctx->Pixel.AlphaBias!=0.0F) {
  561.       ctx->Pixel.ScaleOrBiasRGBA = GL_TRUE;
  562.    }
  563.    else {
  564.       ctx->Pixel.ScaleOrBiasRGBA = GL_FALSE;
  565.    }
  566. }
  567.  
  568.  
  569.  
  570.  
  571. /*
  572.  * Pixel processing functions
  573.  */
  574.  
  575.  
  576. /*
  577.  * Apply scale and bias factors to an array of RGBA pixels.
  578.  */
  579. void gl_scale_and_bias_color( const GLcontext *ctx, GLuint n,
  580.                               GLfloat red[], GLfloat green[],
  581.                               GLfloat blue[], GLfloat alpha[] )
  582. {
  583.    GLuint i;
  584.    for (i=0;i<n;i++) {
  585.       GLfloat r = red[i]   * ctx->Pixel.RedScale   + ctx->Pixel.RedBias;
  586.       GLfloat g = green[i] * ctx->Pixel.GreenScale + ctx->Pixel.GreenBias;
  587.       GLfloat b = blue[i]  * ctx->Pixel.BlueScale  + ctx->Pixel.BlueBias;
  588.       GLfloat a = alpha[i] * ctx->Pixel.AlphaScale + ctx->Pixel.AlphaBias;
  589.       red[i]   = CLAMP( r, 0.0F, 1.0F );
  590.       green[i] = CLAMP( g, 0.0F, 1.0F );
  591.       blue[i]  = CLAMP( b, 0.0F, 1.0F );
  592.       alpha[i] = CLAMP( a, 0.0F, 1.0F );
  593.    }
  594. }
  595.  
  596.  
  597. /*
  598.  * Apply scale and bias factors to an array of RGBA pixels.
  599.  */
  600. void gl_scale_and_bias_rgba( const GLcontext *ctx, GLuint n, GLubyte rgba[][4] )
  601. {
  602.    GLfloat rbias = ctx->Pixel.RedBias   * 255.0F;
  603.    GLfloat gbias = ctx->Pixel.GreenBias * 255.0F;
  604.    GLfloat bbias = ctx->Pixel.BlueBias  * 255.0F;
  605.    GLfloat abias = ctx->Pixel.AlphaBias * 255.0F;
  606.    GLuint i;
  607.    for (i=0;i<n;i++) {
  608.       GLint r = (GLint) (rgba[i][RCOMP] * ctx->Pixel.RedScale   + rbias);
  609.       GLint g = (GLint) (rgba[i][GCOMP] * ctx->Pixel.GreenScale + gbias);
  610.       GLint b = (GLint) (rgba[i][BCOMP] * ctx->Pixel.BlueScale  + bbias);
  611.       GLint a = (GLint) (rgba[i][ACOMP] * ctx->Pixel.AlphaScale + abias);
  612.       rgba[i][RCOMP] = CLAMP( r, 0, 255 );
  613.       rgba[i][GCOMP] = CLAMP( g, 0, 255 );
  614.       rgba[i][BCOMP] = CLAMP( b, 0, 255 );
  615.       rgba[i][ACOMP] = CLAMP( a, 0, 255 );
  616.    }
  617. }
  618.  
  619.  
  620. /*
  621.  * Apply pixel mapping to an array of RGBA pixels.
  622.  */
  623. void gl_map_rgba( const GLcontext *ctx, GLuint n, GLubyte rgba[][4] )
  624. {
  625.    GLfloat rscale = (ctx->Pixel.MapRtoRsize - 1) / 255.0F;
  626.    GLfloat gscale = (ctx->Pixel.MapGtoGsize - 1) / 255.0F;
  627.    GLfloat bscale = (ctx->Pixel.MapBtoBsize - 1) / 255.0F;
  628.    GLfloat ascale = (ctx->Pixel.MapAtoAsize - 1) / 255.0F;
  629.    GLuint i;
  630.    for (i=0;i<n;i++) {
  631.       GLint ir = (GLint) (rgba[i][RCOMP] * rscale);
  632.       GLint ig = (GLint) (rgba[i][GCOMP] * gscale);
  633.       GLint ib = (GLint) (rgba[i][BCOMP] * bscale);
  634.       GLint ia = (GLint) (rgba[i][ACOMP] * ascale);
  635.       rgba[i][RCOMP] = (GLint) (ctx->Pixel.MapRtoR[ir] * 255.0F);
  636.       rgba[i][GCOMP] = (GLint) (ctx->Pixel.MapGtoG[ig] * 255.0F);
  637.       rgba[i][BCOMP] = (GLint) (ctx->Pixel.MapBtoB[ib] * 255.0F);
  638.       rgba[i][ACOMP] = (GLint) (ctx->Pixel.MapAtoA[ia] * 255.0F);
  639.    }
  640. }
  641.  
  642.  
  643. /*
  644.  * Apply pixel mapping to an array of RGBA pixels.
  645.  */
  646. void gl_map_color( const GLcontext *ctx, GLuint n,
  647.                    GLfloat red[], GLfloat green[],
  648.                    GLfloat blue[], GLfloat alpha[] )
  649. {
  650.    GLfloat rscale = ctx->Pixel.MapRtoRsize-1;
  651.    GLfloat gscale = ctx->Pixel.MapGtoGsize-1;
  652.    GLfloat bscale = ctx->Pixel.MapBtoBsize-1;
  653.    GLfloat ascale = ctx->Pixel.MapAtoAsize-1;
  654.    GLuint i;
  655.    for (i=0;i<n;i++) {
  656.       red[i]   = ctx->Pixel.MapRtoR[ (GLint) (red[i]   * rscale) ];
  657.       green[i] = ctx->Pixel.MapGtoG[ (GLint) (green[i] * gscale) ];
  658.       blue[i]  = ctx->Pixel.MapBtoB[ (GLint) (blue[i]  * bscale) ];
  659.       alpha[i] = ctx->Pixel.MapAtoA[ (GLint) (alpha[i] * ascale) ];
  660.    }
  661. }
  662.  
  663.  
  664.  
  665. /*
  666.  * Apply color index shift and offset to an array of pixels.
  667.  */
  668. void gl_shift_and_offset_ci( const GLcontext *ctx, GLuint n, GLuint indexes[] )
  669. {
  670.    GLint shift = ctx->Pixel.IndexShift;
  671.    GLint offset = ctx->Pixel.IndexOffset;
  672.    GLuint i;
  673.    if (shift > 0) {
  674.       for (i=0;i<n;i++) {
  675.          indexes[i] = (indexes[i] << shift) + offset;
  676.       }
  677.    }
  678.    else if (shift < 0) {
  679.       shift = -shift;
  680.       for (i=0;i<n;i++) {
  681.          indexes[i] = (indexes[i] >> shift) + offset;
  682.       }
  683.    }
  684.    else {
  685.       for (i=0;i<n;i++) {
  686.          indexes[i] = indexes[i] + offset;
  687.       }
  688.    }
  689. }
  690.  
  691.  
  692. /*
  693.  * Apply color index mapping to color indexes.
  694.  */
  695. void gl_map_ci( const GLcontext *ctx, GLuint n, GLuint index[] )
  696. {
  697.    GLuint mask = ctx->Pixel.MapItoIsize - 1;
  698.    GLuint i;
  699.    for (i=0;i<n;i++) {
  700.       index[i] = ctx->Pixel.MapItoI[ index[i] & mask ];
  701.    }
  702. }
  703.  
  704.  
  705. /*
  706.  * Map color indexes to rgb values.
  707.  */
  708. void gl_map_ci_to_rgba( const GLcontext *ctx, GLuint n, const GLuint index[],
  709.                         GLubyte rgba[][4] )
  710. {
  711.    GLuint rmask = ctx->Pixel.MapItoRsize - 1;
  712.    GLuint gmask = ctx->Pixel.MapItoGsize - 1;
  713.    GLuint bmask = ctx->Pixel.MapItoBsize - 1;
  714.    GLuint amask = ctx->Pixel.MapItoAsize - 1;
  715.    const GLubyte *rMap = ctx->Pixel.MapItoR8;
  716.    const GLubyte *gMap = ctx->Pixel.MapItoG8;
  717.    const GLubyte *bMap = ctx->Pixel.MapItoB8;
  718.    const GLubyte *aMap = ctx->Pixel.MapItoA8;
  719.    GLuint i;
  720.    for (i=0;i<n;i++) {
  721.       rgba[i][RCOMP] = rMap[index[i] & rmask];
  722.       rgba[i][GCOMP] = gMap[index[i] & gmask];
  723.       rgba[i][BCOMP] = bMap[index[i] & bmask];
  724.       rgba[i][ACOMP] = aMap[index[i] & amask];
  725.    }
  726. }
  727.  
  728.  
  729. /*
  730.  * Map 8-bit color indexes to rgb values.
  731.  */
  732. void gl_map_ci8_to_rgba( const GLcontext *ctx, GLuint n, const GLubyte index[],
  733.                          GLubyte rgba[][4] )
  734. {
  735.    GLuint rmask = ctx->Pixel.MapItoRsize - 1;
  736.    GLuint gmask = ctx->Pixel.MapItoGsize - 1;
  737.    GLuint bmask = ctx->Pixel.MapItoBsize - 1;
  738.    GLuint amask = ctx->Pixel.MapItoAsize - 1;
  739.    const GLubyte *rMap = ctx->Pixel.MapItoR8;
  740.    const GLubyte *gMap = ctx->Pixel.MapItoG8;
  741.    const GLubyte *bMap = ctx->Pixel.MapItoB8;
  742.    const GLubyte *aMap = ctx->Pixel.MapItoA8;
  743.    GLuint i;
  744.    for (i=0;i<n;i++) {
  745.       rgba[i][RCOMP] = rMap[index[i] & rmask];
  746.       rgba[i][GCOMP] = gMap[index[i] & gmask];
  747.       rgba[i][BCOMP] = bMap[index[i] & bmask];
  748.       rgba[i][ACOMP] = aMap[index[i] & amask];
  749.    }
  750. }
  751.  
  752.  
  753. void gl_map_ci_to_color( const GLcontext *ctx, GLuint n, const GLuint index[],
  754.                          GLfloat r[], GLfloat g[],
  755.                          GLfloat b[], GLfloat a[] )
  756. {
  757.    GLuint rmask = ctx->Pixel.MapItoRsize - 1;
  758.    GLuint gmask = ctx->Pixel.MapItoGsize - 1;
  759.    GLuint bmask = ctx->Pixel.MapItoBsize - 1;
  760.    GLuint amask = ctx->Pixel.MapItoAsize - 1;
  761.    GLuint i;
  762.    for (i=0;i<n;i++) {
  763.       r[i] = ctx->Pixel.MapItoR[index[i] & rmask];
  764.       g[i] = ctx->Pixel.MapItoG[index[i] & gmask];
  765.       b[i] = ctx->Pixel.MapItoB[index[i] & bmask];
  766.       a[i] = ctx->Pixel.MapItoA[index[i] & amask];
  767.    }
  768. }
  769.  
  770.  
  771.  
  772. void gl_shift_and_offset_stencil( const GLcontext *ctx, GLuint n,
  773.                                   GLstencil stencil[] )
  774. {
  775.    GLuint i;
  776.    GLint shift = ctx->Pixel.IndexShift;
  777.    GLint offset = ctx->Pixel.IndexOffset;
  778.    if (shift > 0) {
  779.       for (i=0;i<n;i++) {
  780.          stencil[i] = (stencil[i] << shift) + offset;
  781.       }
  782.    }
  783.    else if (shift < 0) {
  784.       shift = -shift;
  785.       for (i=0;i<n;i++) {
  786.          stencil[i] = (stencil[i] >> shift) + offset;
  787.       }
  788.    }
  789.    else {
  790.       for (i=0;i<n;i++) {
  791.          stencil[i] = stencil[i] + offset;
  792.       }
  793.    }
  794.  
  795. }
  796.  
  797.  
  798.  
  799. void gl_map_stencil( const GLcontext *ctx, GLuint n, GLstencil stencil[] )
  800. {
  801.    GLuint mask = ctx->Pixel.MapStoSsize - 1;
  802.    GLuint i;
  803.    for (i=0;i<n;i++) {
  804.       stencil[i] = ctx->Pixel.MapStoS[ stencil[i] & mask ];
  805.    }
  806. }
  807.  
  808.